#!/usr/bin/python
# -*- coding: utf-8 -*-
from DBA.dbmanager import DBInterface

class PerfWifi:
    """
    Classe d acces a la liste complete des mesure de débits Wifi pour une mesure globale (qui contient aussi les cellules Wifi, mesure radio, ...)
    Table: PR5QTPW
    """   
    def __init__(self):
        """
        Constructeur
        """
        self.id            = {"key":"ID","value":""}
        self.ensPerf        = []
        self.__interfacebase    = DBInterface()
        self.id["value"]    = str(self.__interfacebase.createNewID());
    
    def createByListeDico(self,liste):
        """
        Creation d'un ensemble de dictionnaire de mesure de debit
        @param liste de performances mesurees
        """
        for perf in liste:
            pe = Perf()
            pe.createByDico(perf)
            self.addPerf(pe)

    def addPerf(self,perf):
        """
        Ajout d'une mesure de debit a la liste en cours
        @param perf objet de type Perf()
        """
        self.ensPerf.append(perf)
    
    def nbPerfs(self):
        """
        Retourne le nombre de mesures de debits pour la liste en cours
        """
        return self.ensPerf.count()
    
    def insertToDb(self,idMesure):
        """
        Insertion de la liste de mesures de debits (Performances) en cours dans la BDD. Relative a la mesure generale
        @param idMesure identificateur unique de mesure globale
        """
        inter   = self.createPerfDico(idMesure)
        self.__interfacebase.insert(self.__interfacebase.ref_iperf_mesuretablename,self.__interfacebase.ref_iperf_mesuremapping,inter)
        for perf in self.ensPerf:
            perf.insertToDb(self.id["value"])

    def deleteFromDb(self,idMesure):
        """
        Suppression des mesures de debits relatives a la mesure globable
        @param idMesure identificateur unique de mesure globale
        """
        key={}
        key['link_me']=idMesure
        #Je recupere l'id des perfs
        self.selectPerfWifiFromDB(idMesure)
        #Au cas ou il n'y ai pas de perfs
        elementsuppr=0
        if (self.ensPerfWifi):
            #Je supprime la performance
            perf= Perf()
            elementsuppr=int(perf.deleteFromDb(self.ensPerfWifi[0]['ID']))
            #Et je supprime l'association
            key['ID']=self.ensPerfWifi[0]['ID']
            elementsuppr=elementsuppr + int(self.__interfacebase.deleteFromTable(self.__interfacebase.ref_iperf_mesuretablename,self.__interfacebase.ref_iperf_mesuremapping,key))
        return elementsuppr


    def updateIntoDb(self,idMesure):
        """
        Mise a jour de la liste de mesure de debits pour une mesure globale
        @param idMesure identificateur unique de mesure globale        
        """
        inter   = self.createPerfDico(idMesure)
        self.__interfacebase.update(self.__interfacebase.ref_iperf_mesuretablename,self.__interfacebase.ref_iperf_mesuremapping,inter)
        for perf in self.ensPerf:
            perf.updateIntoDb(self.id["value"])

    def selectPerfWifiFromDB(self,identificateur):
        """
        Retourne toutes les mesures de débits pour une mesure globale
        @param identificateur identificateur unique de mesure globale
        """
        pe=Perf()
        key ={}
        key["link_me"] = identificateur
        self.ensPerfWifi = self.__interfacebase.selectTable(self.__interfacebase.ref_iperf_mesuretablename,self.__interfacebase.ref_iperf_mesuremapping,key)
        #Si j'ai des perfs alors je retourne leur identifiant
        if (self.ensPerfWifi):
            return pe.selectPerfFromDB(self.ensPerfWifi[0]['ID'])
        #Sinon non.
        else:
            return []

    def createPerfDico(self,idMesure):
        """
        Creation d'un dictionnaire associant une mesure globale et une liste de mesure de debits
        @param idMesure identificateur de mesure globale
        """
        dico ={}
        dico[self.id["key"]]        = self.id["value"]
        dico["link_me"]            = idMesure
        return dico

class Perf:
    """
    Classe d'acces aux mesures de debits effectues
    Table: PR5QTPE
    """   
    def __init__(self):
        """
        Constructeur
        """
        self.id            = {"key":"ID","value":""}
        self.bandePassante    = {"key":"bande_passante","value":""}
        self.intervalle        = {"key":"intervalles","value":""}
        self.transfere        = {"key":"transfere","value":""}
        self.__interfacebase    = DBInterface()
        self.id["value"]    = str(self.__interfacebase.createNewID());
    
    def createByDico(self,dico):
        """
        Creation d'une mesure de debit depuis un dictionnaire cree en page7.py
        @param dico dictionnaire de la mesure
        """
        self.bandePassante["value"]    = dico[self.bandePassante["key"]]
        self.intervalle["value"]    = dico[self.intervalle["key"]] 
        self.transfere["value"]        = dico[self.transfere["key"]]

    def insertToDb(self,idPerf):
        """
        Insertion d'une mesure de débit dans la BDD
        @param idPerf identificateur unique de la mesure
        """
        dico     = self.createConfigPerfDico(idPerf)
        self.__interfacebase.insert(self.__interfacebase.iperftablename,self.__interfacebase.iperfmapping,dico)

    def deleteFromDb(self,idPerf):
        """
        Suppression d'une mesure de debit dans la BDD
        @param idPerf identificateur unique de la mesure
        """
        key={}
        key['ID']=idPerf
        return self.__interfacebase.deleteFromTable(self.__interfacebase.iperftablename,self.__interfacebase.iperfmapping,key)

    def selectPerfFromDB(self,identificateur):
        """
        Retourne les mesures de debits par rapport a l'identificateur passe en parametre
        @param identificateur identificateur unique de la mesure de debit
        """
        key ={}
        key["ID"] = identificateur
        ensPerf = self.__interfacebase.selectTable(self.__interfacebase.iperftablename,self.__interfacebase.iperfmapping,key)
        return ensPerf
    
    def createConfigPerfDico(self,idPerf):
        """
        Creation d'un dictionnaire de mesure de debit depuis un identificateur de perf passe en parametre
        @param idPerf identificateur unique de la mesure de debit
        """
        dico ={}
        dico[self.id["key"]]        = idPerf
        dico[self.bandePassante["key"]]    = self.bandePassante["value"]
        dico[self.intervalle["key"]]    = self.intervalle["value"]
        dico[self.transfere["key"]]    = self.transfere["value"]
        return dico
    
